home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / comm / mail / Mutt089src.lha / Mutt-0.89i-AMIGA / src / menu.c < prev    next >
C/C++ Source or Header  |  1998-01-28  |  17KB  |  793 lines
  1. /*
  2.  * Copyright (C) 1996-8 Michael R. Elkins <me@cs.hmc.edu>
  3.  *
  4.  *     This program is free software; you can redistribute it and/or modify
  5.  *     it under the terms of the GNU General Public License as published by
  6.  *     the Free Software Foundation; either version 2 of the License, or
  7.  *     (at your option) any later version.
  8.  *
  9.  *     This program is distributed in the hope that it will be useful,
  10.  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  *     GNU General Public License for more details.
  13.  *
  14.  *     You should have received a copy of the GNU General Public License
  15.  *     along with this program; if not, write to the Free Software
  16.  *     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  */
  18.  
  19. #include "mutt.h"
  20. #include "mutt_curses.h"
  21. #include "mutt_menu.h"
  22.  
  23. #include <string.h>
  24. #include <stdlib.h>
  25.  
  26. #define M_MODEFMT "-- Mutt: %s"
  27.  
  28. static void print_enriched_string (unsigned char *s, int do_color)
  29. {
  30.   while (*s)
  31.   {
  32.     if (*s < ctrl ('I'))
  33.     {
  34.       if (do_color)
  35.     SETCOLOR (MT_COLOR_TREE);
  36.       while (*s && *s < ctrl ('I'))
  37.       {
  38.     switch (*s)
  39.     {
  40.       case 1:
  41.         addch (option (OPTASCIICHARS) ? '`' : ACS_LLCORNER);
  42.         break;
  43.       case 2:
  44.         addch (option (OPTASCIICHARS) ? ',' : ACS_ULCORNER);
  45.         break;
  46.       case 3:
  47.         addch (option (OPTASCIICHARS) ? '|' : ACS_LTEE);
  48.         break;
  49.       case 4:
  50.         addch (option (OPTASCIICHARS) ? '-' : ACS_HLINE);
  51.         break;
  52.       case 5:
  53.         addch (option (OPTASCIICHARS) ? '|' : ACS_VLINE);
  54.         break;
  55.       case 6:
  56.         addch (' ');
  57.         break;
  58.       case 7:
  59.         addch ('>');
  60.         break;
  61.       case 8:
  62.         addch ('*'); /* fake thread indicator */
  63.         break;
  64.     }
  65.     s++;
  66.       }
  67.       if (do_color)
  68.     SETCOLOR (MT_COLOR_NORMAL);
  69.     }
  70.     else
  71.     {
  72.       addch (*s);
  73.       s++;
  74.     }
  75.   }
  76. }
  77.  
  78. void menu_pad_string (char *s, size_t l)
  79. {
  80. #if !defined(HAVE_BKGDSET) && !defined (USE_SLANG_CURSES)
  81.   int n = strlen (s);
  82. #endif
  83.   int shift = option (OPTARROWCURSOR) ? 3 : 0;
  84.   
  85.   l--; /* save room for the terminal \0 */
  86.   if (l > COLS - shift)
  87.     l = COLS - shift;
  88. #if !defined (HAVE_BKGDSET) && !defined (USE_SLANG_CURSES)
  89.   /* we have to pad the string with blanks to the end of line */
  90.   if (n < l)
  91.   {
  92.     while (n < l)
  93.       s[n++] = ' ';
  94.     s[n] = 0;
  95.   }
  96.   else
  97. #endif
  98.     s[l] = 0;
  99. }
  100.  
  101. void menu_redraw_full (MUTTMENU *menu)
  102. {
  103.   SETCOLOR (MT_COLOR_NORMAL);
  104.   /* clear() doesn't optimize screen redraws */
  105.   move (0, 0);
  106.   clrtobot ();
  107.  
  108.   if (option (OPTHELP))
  109.   {
  110.     SETCOLOR (MT_COLOR_STATUS);
  111.     mvprintw (option (OPTSTATUSONTOP) ? LINES-2 : 0, 0, "%-*.*s", COLS, COLS, menu->help);
  112.     SETCOLOR (MT_COLOR_NORMAL);
  113.     menu->offset = 1;
  114.     menu->pagelen = LINES - 3;
  115.   }
  116.   else
  117.   {
  118.     menu->offset = option (OPTSTATUSONTOP) ? 1 : 0;
  119.     menu->pagelen = LINES - 2;
  120.   }
  121.  
  122.   mutt_show_error ();
  123.  
  124.   menu->redraw = REDRAW_INDEX | REDRAW_STATUS;
  125. }
  126.  
  127. void menu_redraw_index (MUTTMENU *menu)
  128. {
  129.   char buf[STRING];
  130.   int i;
  131.  
  132.   for (i = menu->top; i < menu->top + menu->pagelen; i++)
  133.   {
  134.     if (i < menu->max)
  135.     {
  136.       menu->make_entry (buf, sizeof (buf), menu, i);
  137.       menu_pad_string (buf, sizeof (buf));
  138.  
  139.       if (option (OPTARROWCURSOR))
  140.       {
  141.     CLEARLINE (i - menu->top + menu->offset);
  142.  
  143.     if (i == menu->current)
  144.     {
  145.       SETCOLOR (MT_COLOR_INDICATOR);
  146.       addstr ("->");
  147.       SETCOLOR (MT_COLOR_NORMAL);
  148.       addch (' ');
  149.     }
  150.     else
  151.       move (i - menu->top + menu->offset, 3);
  152.     print_enriched_string ((unsigned char *) buf, 1);
  153.       }
  154.       else
  155.       {
  156.     if (i == menu->current)
  157.     {
  158.       SETCOLOR (MT_COLOR_INDICATOR);
  159.       BKGDSET (MT_COLOR_INDICATOR);
  160.     }
  161.     CLEARLINE (i - menu->top + menu->offset);
  162.     print_enriched_string ((unsigned char *) buf, i != menu->current);
  163.     if (i == menu->current)
  164.     {
  165.       SETCOLOR (MT_COLOR_NORMAL);
  166.       BKGDSET (MT_COLOR_NORMAL);
  167.     }
  168.       }
  169.     }
  170.     else
  171.       CLEARLINE (i - menu->top + menu->offset);
  172.   }
  173.   menu->redraw = 0;
  174. }
  175.  
  176. void menu_redraw_motion (MUTTMENU *menu)
  177. {
  178.   char buf[STRING];
  179.   
  180.   move (menu->oldcurrent + menu->offset - menu->top, 0);
  181.   SETCOLOR (MT_COLOR_NORMAL);
  182.   BKGDSET (MT_COLOR_NORMAL);
  183.  
  184.   if (option (OPTARROWCURSOR))
  185.   {
  186.     /* clear the pointer */
  187.     addstr ("  ");
  188.  
  189.     if (menu->redraw & REDRAW_MOTION_RESYNCH)
  190.     {
  191.       clrtoeol ();
  192.       menu->make_entry (buf, sizeof (buf), menu, menu->oldcurrent);
  193.       menu_pad_string (buf, sizeof (buf));
  194.       move (menu->oldcurrent + menu->offset - menu->top, 3);
  195.       print_enriched_string ((unsigned char *) buf, 1);
  196.     }
  197.  
  198.     /* now draw it in the new location */
  199.     move (menu->current + menu->offset - menu->top, 0);
  200.     SETCOLOR (MT_COLOR_INDICATOR);
  201.     addstr ("->");
  202.     SETCOLOR (MT_COLOR_NORMAL);
  203.   }
  204.   else
  205.   {
  206.     /* erase the current indicator */
  207.     clrtoeol ();
  208.     menu->make_entry (buf, sizeof (buf), menu, menu->oldcurrent);
  209.     menu_pad_string (buf, sizeof (buf));
  210.     print_enriched_string ((unsigned char *) buf, 1);
  211.  
  212.     /* now draw the new one to reflect the change */
  213.     menu->make_entry (buf, sizeof (buf), menu, menu->current);
  214.     menu_pad_string (buf, sizeof (buf));
  215.     SETCOLOR (MT_COLOR_INDICATOR);
  216.     BKGDSET (MT_COLOR_INDICATOR);
  217.     CLEARLINE (menu->current - menu->top + menu->offset);
  218.     print_enriched_string ((unsigned char *) buf, 0);
  219.     SETCOLOR (MT_COLOR_NORMAL);
  220.     BKGDSET (MT_COLOR_NORMAL);
  221.   }
  222.   menu->redraw = 0;
  223. }
  224.  
  225. void menu_redraw_current (MUTTMENU *menu)
  226. {
  227.   char buf[STRING];
  228.   
  229.   move (menu->current + menu->offset - menu->top, 0);
  230.   menu->make_entry (buf, sizeof (buf), menu, menu->current);
  231.   menu_pad_string (buf, sizeof (buf));
  232.  
  233.   if (option (OPTARROWCURSOR))
  234.   {
  235.     clrtoeol ();
  236.     SETCOLOR (MT_COLOR_INDICATOR);
  237.     addstr ("->");
  238.     SETCOLOR (MT_COLOR_NORMAL);
  239.     addch (' ');
  240.     menu_pad_string (buf, sizeof (buf));
  241.     print_enriched_string ((unsigned char *) buf, 1);
  242.   }
  243.   else
  244.   {
  245.     SETCOLOR (MT_COLOR_INDICATOR);
  246.     BKGDSET (MT_COLOR_INDICATOR);
  247.     clrtoeol ();
  248.     print_enriched_string ((unsigned char *) buf, 0);
  249.     SETCOLOR (MT_COLOR_NORMAL);
  250.     BKGDSET (MT_COLOR_NORMAL);
  251.   }
  252.   menu->redraw = 0;
  253. }
  254.  
  255. void menu_check_recenter (MUTTMENU *menu)
  256. {
  257.   if (menu->current >= menu->top + menu->pagelen)
  258.   {
  259.     if (option (OPTMENUSCROLL))
  260.       menu->top = menu->current - menu->pagelen + 1;
  261.     else
  262.       menu->top += menu->pagelen * ((menu->current - menu->top) / menu->pagelen);
  263.     menu->redraw = REDRAW_INDEX;
  264.   }
  265.   else if (menu->current < menu->top)
  266.   {
  267.     if (option (OPTMENUSCROLL))
  268.       menu->top = menu->current;
  269.     else
  270.     {
  271.       menu->top -= menu->pagelen * ((menu->top + menu->pagelen - 1 - menu->current) / menu->pagelen);
  272.       if (menu->top < 0)
  273.     menu->top = 0;
  274.     }
  275.     menu->redraw = REDRAW_INDEX;
  276.   }
  277. }
  278.  
  279. void menu_jump (MUTTMENU *menu)
  280. {
  281.   int n;
  282.   char buf[SHORT_STRING];
  283.  
  284.   if (menu->max)
  285.   {
  286.     mutt_ungetch (LastKey);
  287.     buf[0] = 0;
  288.     if (mutt_get_field ("Jump to: ", buf, sizeof (buf), 0) == 0 && buf[0])
  289.     {
  290.       n = atoi (buf) - 1;
  291.       if (n >= 0 && n < menu->max)
  292.       {
  293.     menu->current = n;
  294.     menu->redraw = REDRAW_MOTION;
  295.       }
  296.       else
  297.     mutt_error ("Invalid index number.");
  298.     }
  299.   }
  300.   else
  301.     mutt_error ("No entries.");
  302. }
  303.  
  304. void menu_next_line (MUTTMENU *menu)
  305. {
  306.   if (menu->max)
  307.   {
  308.     if (menu->top < menu->max - 1)
  309.     {
  310.       menu->top++;
  311.       if (menu->current < menu->top)
  312.     menu->current++;
  313.       menu->redraw = REDRAW_INDEX;
  314.     }
  315.     else
  316.       mutt_error ("You cannot scroll down farther.");
  317.   }
  318.   else
  319.     mutt_error ("No entries.");
  320. }
  321.  
  322. void menu_prev_line (MUTTMENU *menu)
  323. {
  324.   if (menu->top > 0)
  325.   {
  326.     menu->top--;
  327.     if (menu->current >= menu->top + menu->pagelen)
  328.       menu->current--;
  329.     menu->redraw = REDRAW_INDEX;
  330.   }
  331.   else
  332.     mutt_error ("You cannot scroll up farther.");
  333. }
  334.  
  335. void menu_next_page (MUTTMENU *menu)
  336. {
  337.   if (menu->max)
  338.   {
  339.     if (menu->top + menu->pagelen < menu->max)
  340.     {
  341.       menu->top += menu->pagelen;
  342.       if (menu->current < menu->top)
  343.     menu->current = menu->top;
  344.       menu->redraw = REDRAW_INDEX;
  345.     }
  346.     else if (menu->current != menu->max - 1)
  347.     {
  348.       menu->current = menu->max - 1;
  349.       menu->redraw = REDRAW_MOTION;
  350.     }
  351.     else
  352.       mutt_error ("You are on the last page.");
  353.   }
  354.   else
  355.     mutt_error ("No entries.");
  356. }
  357.  
  358. void menu_prev_